package com.doctracker.service;

import com.doctracker.model.Person;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Excel文件导入服务类
 * 负责从Excel文件中读取人员名单
 */
public class ExcelService {
    
    /**
     * 从Excel文件导入人员名单
     * 支持.xls和.xlsx格式
     * 
     * @param excelFile Excel文件
     * @return 人员列表
     * @throws IOException 文件读取异常
     */
    public List<Person> importFromExcel(File excelFile) throws IOException {
        List<Person> people = new ArrayList<>();
        
        // 验证文件格式
        if (!isValidExcelFile(excelFile)) {
            throw new IllegalArgumentException("不支持的文件格式，请选择.xls或.xlsx文件");
        }
        
        try (FileInputStream fis = new FileInputStream(excelFile)) {
            Workbook workbook = createWorkbook(excelFile, fis);
            
            // 读取第一个工作表
            Sheet sheet = workbook.getSheetAt(0);
            
            System.out.println("开始读取Excel文件: " + excelFile.getName());
            System.out.println("工作表名称: " + sheet.getSheetName());
            System.out.println("总行数: " + sheet.getPhysicalNumberOfRows());
            
            // 读取表头，获取字段名称
            List<String> fieldNames = new ArrayList<>();
            int nameColumnIndex = -1; // 姓名列索引
            int headerRowIndex = findHeaderRow(sheet); // 智能查找表头行
            
            Row headerRow = sheet.getRow(headerRowIndex);
            if (headerRow != null) {
                for (Cell cell : headerRow) {
                    String fieldName = getCellValue(cell);
                    if (fieldName != null && !fieldName.trim().isEmpty()) {
                        fieldNames.add(fieldName.trim());
                        System.out.println("检测到字段: " + fieldName.trim());
                        
                        // 智能识别姓名列
                        if (nameColumnIndex == -1 && isNameColumn(fieldName.trim())) {
                            nameColumnIndex = fieldNames.size() - 1;
                            System.out.println("识别到姓名列，索引: " + nameColumnIndex);
                        }
                    } else {
                        fieldNames.add(null); // 保持位置对应
                    }
                }
            }
            
            // 如果没有找到姓名列，默认使用第一列
            if (nameColumnIndex == -1) {
                nameColumnIndex = 0;
                System.out.println("未找到明确的姓名列，使用第一列作为姓名列");
            }
            
            // 遍历数据行
            for (Row row : sheet) {
                // 跳过表头行
                if (row.getRowNum() <= headerRowIndex) {
                    continue;
                }
                
                // 读取姓名列作为姓名（必需字段）
                Cell nameCell = row.getCell(nameColumnIndex);
                if (nameCell != null) {
                    String name = getCellValue(nameCell);
                    
                    // 验证姓名不为空
                    if (name != null && !name.trim().isEmpty()) {
                        Person person = new Person(name.trim());
                        
                        // 读取其他列作为动态字段（跳过姓名列）
                        for (int i = 0; i < fieldNames.size() && i < row.getPhysicalNumberOfCells(); i++) {
                            // 跳过姓名列，避免重复存储
                            if (i == nameColumnIndex) {
                                continue;
                            }
                            
                            String fieldName = fieldNames.get(i);
                            if (fieldName != null) {
                                Cell cell = row.getCell(i);
                                if (cell != null) {
                                    String value = getCellValue(cell);
                                    if (value != null && !value.trim().isEmpty()) {
                                        person.setDynamicField(fieldName, value.trim());
                                        System.out.println("  " + fieldName + ": " + value.trim());
                                    }
                                }
                            }
                        }
                        
                        people.add(person);
                        System.out.println("读取人员: " + name.trim() + " (包含 " + person.getAvailableFields().size() + " 个额外字段)");
                    }
                }
            }
            
            workbook.close();
        }
        
        System.out.println("Excel导入完成，共导入 " + people.size() + " 个人员");
        return people;
    }
    
    /**
     * 验证Excel文件格式
     * 
     * @param file 文件对象
     * @return 是否为有效的Excel文件
     */
    private boolean isValidExcelFile(File file) {
        if (file == null || !file.exists()) {
            return false;
        }
        
        String fileName = file.getName().toLowerCase();
        return fileName.endsWith(".xls") || fileName.endsWith(".xlsx");
    }
    
    /**
     * 根据文件类型创建对应的Workbook
     * 
     * @param file Excel文件
     * @param fis 文件输入流
     * @return Workbook对象
     * @throws IOException 文件读取异常
     */
    private Workbook createWorkbook(File file, FileInputStream fis) throws IOException {
        String fileName = file.getName().toLowerCase();
        
        if (fileName.endsWith(".xlsx")) {
            // Excel 2007+ 格式
            return new XSSFWorkbook(fis);
        } else if (fileName.endsWith(".xls")) {
            // Excel 97-2003 格式
            return new HSSFWorkbook(fis);
        } else {
            throw new IllegalArgumentException("不支持的Excel文件格式");
        }
    }
    
    /**
     * 获取单元格的字符串值
     * 处理不同类型的单元格数据
     * 
     * @param cell 单元格对象
     * @return 单元格的字符串值
     */
    private String getCellValue(Cell cell) {
        if (cell == null) {
            return null;
        }
        
        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                // 如果是数字，转换为字符串（可能是学号等）
                if (DateUtil.isCellDateFormatted(cell)) {
                    return cell.getDateCellValue().toString();
                } else {
                    // 避免科学计数法显示
                    double numericValue = cell.getNumericCellValue();
                    if (numericValue == (long) numericValue) {
                        return String.valueOf((long) numericValue);
                    } else {
                        return String.valueOf(numericValue);
                    }
                }
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                // 对于公式单元格，获取计算后的值
                return getCellValue(cell);
            default:
                return null;
        }
    }
    
    /**
     * 验证Excel文件内容
     * 检查是否包含有效的姓名数据
     * 
     * @param excelFile Excel文件
     * @return 是否包含有效数据
     */
    public boolean validateExcelContent(File excelFile) {
        try {
            List<Person> people = importFromExcel(excelFile);
            return !people.isEmpty();
        } catch (Exception e) {
            System.err.println("验证Excel文件失败: " + e.getMessage());
            return false;
        }
    }
    
    /**
     * 智能查找表头行
     * 
     * @param sheet 工作表
     * @return 表头行索引
     */
    private int findHeaderRow(Sheet sheet) {
        // 遍历前5行，找到包含"姓名"或多个字段的行作为表头
        for (int i = 0; i < Math.min(5, sheet.getPhysicalNumberOfRows()); i++) {
            Row row = sheet.getRow(i);
            if (row == null) continue;
            
            List<String> cellValues = new ArrayList<>();
            for (Cell cell : row) {
                String value = getCellValue(cell);
                if (value != null && !value.trim().isEmpty()) {
                    cellValues.add(value.trim());
                }
            }
            
            // 如果这一行有多个独立的字段（不是合并的说明文字），认为是表头
            if (cellValues.size() >= 2) {
                // 进一步验证：是否包含常见的表头字段
                boolean hasCommonHeaders = false;
                for (String value : cellValues) {
                    String lowerValue = value.toLowerCase();
                    if (lowerValue.contains("姓名") || lowerValue.contains("name") || 
                        lowerValue.contains("序号") || lowerValue.contains("学号") ||
                        lowerValue.contains("班级") || lowerValue.contains("编号")) {
                        hasCommonHeaders = true;
                        break;
                    }
                }
                
                if (hasCommonHeaders) {
                    System.out.println("找到表头行，索引: " + i + "，字段: " + cellValues);
                    return i;
                }
            }
        }
        
        // 如果没找到合适的表头行，默认使用第0行
        System.out.println("未找到明确的表头行，使用第0行");
        return 0;
    }
    
    /**
     * 判断是否为姓名列
     * 
     * @param columnName 列名
     * @return 是否为姓名列
     */
    private boolean isNameColumn(String columnName) {
        if (columnName == null || columnName.trim().isEmpty()) {
            return false;
        }
        
        String name = columnName.trim().toLowerCase();
        return name.contains("姓名") || 
               name.contains("name") || 
               name.equals("学生姓名") ||
               name.equals("真实姓名") ||
               name.equals("中文姓名") ||
               name.contains("名字");
    }
} 